const dayjs = require('dayjs');
/**
 * 研发项目资源管理模块
 * 负责处理研发项目中资源文件的管理、上传、下载、预览等功能
 */

// 引入辅助工具
const cloudHelper = require('../../../config/project_helpers_config').cloudHelper;
const pageHelper = require('../../../config/project_helpers_config').pageHelper;
const timeHelper = require('../../../config/project_helpers_config').timeHelper;

// 引入基础文件管理模块
const BaseFileManager = require('../common/base_file_manager');

// 引入业务逻辑
const ProjectVersionBiz = require('../../../config/path_resolver.js').pageHelper;

/**
 * 资源管理器类
 * 用于处理研发项目中的各类资源文件
 */
class ResourceManager extends BaseFileManager {
  /**
   * 构造函数
   * @param {Object} page - 页面实例
   * @param {Object} options - 配置选项
   */
  constructor(page, options = {}) {
    super(page, options);
  }

  /**
   * 初始化资源文件夹结构
   * @returns {Array} 资源文件夹结构
   */
  initResourceFolders() {
    return [
      { id: 'package', name: '包装指引', files: [] },
      { id: 'process', name: '加工指引', files: [] },
      { id: 'material', name: '物料变更通知', files: [] },
      { id: 'bom', name: 'BOM', files: [] },
      { id: 'report', name: '认证报告', files: [] },
      { id: 'test_report', name: '测试报告', files: [] },
      { id: 'test_guide', name: '测试指引', files: [] },
      { id: 'spec', name: '产品规格书', files: [] },
      { id: 'code', name: '代码', files: [] },
      { id: 'firmware', name: '烧录文件', files: [] },
      { id: 'structure', name: '结构', files: [] },
      { id: 'customer', name: '客户文件', files: [] },
      { id: 'component', name: '元器件 规格书', files: [] },
      { id: 'schematic', name: '原理图', files: [] },
      { id: 'pcb', name: 'PCB', files: [] },
      { id: 'manual', name: '作业指导书', files: [], active: true }
    ];
  }

  /**
   * 获取最新的资源版本列表
   * @param {string} projectId - 项目ID
   * @param {boolean} useCache - 是否使用缓存
   * @returns {Promise<Array>} 资源版本列表
   */
  async getResourceVersionList(projectId, useCache = true) {
    // 检查缓存
    const cacheKey = `resource_versions_${projectId}`;
    const cachedData = useCache ? this.getCache(cacheKey) : null;
    if (cachedData) {
      return cachedData;
    }

    try {
      // 请求服务器数据
      const params = {
        projectId: projectId
      };
      
      const result = await this.callApiWithLoading('research/get_resource_versions', params, '获取资源列表');
      
      // 更新缓存
      this.setCache(cacheKey, result);
      
      return result;
    } catch (error) {
      console.error('获取资源版本列表失败', error);
      throw error;
    }
  }

  /**
   * 获取最新版本的资源
   * @param {Array} resourceList - 资源列表
   * @returns {Array} 最新版本的资源列表
   */
  getLatestResourceVersions(resourceList) {
    if (!resourceList || !Array.isArray(resourceList)) return [];

    // 按资源类型分组
    const resourceMap = {};
    resourceList.forEach(resource => {
      const type = resource.RESOURCE_TYPE;
      if (!resourceMap[type]) {
        resourceMap[type] = [];
      }
      resourceMap[type].push(resource);
    });

    // 对每种类型取最新版本
    const latestResources = [];
    for (const type in resourceMap) {
      // 按版本排序
      const sorted = resourceMap[type].sort((a, b) => {
        return dayjs(b.RESOURCE_ADD_TIME).valueOf() - dayjs(a.RESOURCE_ADD_TIME).valueOf();
      });
      
      latestResources.push(sorted[0]);
    }

    return latestResources;
  }

  /**
   * 处理资源数据，将资源分配到对应的文件夹
   * @param {Array} resourceFolders - 资源文件夹结构
   * @param {Array} resources - 资源列表
   * @returns {Array} 处理后的资源文件夹
   */
  processResourceData(resourceFolders, resources) {
    if (!resources || !Array.isArray(resources)) return resourceFolders;
    
    // 清空所有文件夹的文件列表
    resourceFolders.forEach(folder => {
      folder.files = [];
    });

    // 将资源按类型分配到对应文件夹
    resources.forEach(resource => {
      const type = resource.RESOURCE_TYPE.toLowerCase();
      
      // 查找对应的文件夹
      let targetFolder = resourceFolders.find(folder => folder.id === type);
      
      // 如果找不到对应文件夹，放入客户文件文件夹
      if (!targetFolder) {
        targetFolder = resourceFolders.find(folder => folder.id === 'customer');
      }
      
      if (targetFolder) {
        // 格式化文件大小和时间
        resource.RESOURCE_SIZE_DISPLAY = this.formatFileSize(resource.RESOURCE_SIZE || 0);
        resource.RESOURCE_ADD_TIME_DISPLAY = this._formatDateTime(resource.RESOURCE_ADD_TIME);
        
        // 添加到文件夹
        targetFolder.files.push(resource);
      }
    });

    // 按时间排序每个文件夹中的文件
    resourceFolders.forEach(folder => {
      folder.files.sort((a, b) => {
        return dayjs(b.RESOURCE_ADD_TIME).valueOf() - dayjs(a.RESOURCE_ADD_TIME).valueOf();
      });
    });

    return resourceFolders;
  }

  /**
   * 上传资源文件
   * @param {Object} resource - 资源信息
   * @returns {Promise<Object>} 上传结果
   */
  async uploadResource(resource) {
    if (!resource) return null;
    
    try {
      // 扩展额外的资源信息
      const extraData = {
        version: resource.version || '1.0',
        desc: resource.desc || '',
        flowId: resource.flowId || ''
      };
      
      // 使用基类的上传文件方法
      return await this.uploadFile(resource, 'resource', extraData, 'research/upload_resource');
    } catch (error) {
      console.error('上传资源失败', error);
      throw error;
    }
  }

  /**
   * 预览资源文件
   * @param {Object} resource - 资源对象
   * @param {Object} options - 预览选项
   * @returns {Promise<void>}
   */
  async viewResource(resource, options = {}) {
    if (!resource || !resource.RESOURCE_FILE_ID) {
      pageHelper.showError('资源文件不存在');
      return;
    }

    try {
      // 标准化资源对象
      const file = {
        fileId: resource.RESOURCE_FILE_ID,
        name: resource.RESOURCE_NAME
      };

      // 根据资源类型选择不同的预览方式
      const type = resource.RESOURCE_TYPE.toLowerCase();
      
      switch (type) {
        case 'schematic':
          await this._viewSchematicResource(resource);
          break;
        case 'pcb':
          await this._viewPcbResource(resource);
          break;
        case 'bom':
          await this._viewBomResource(resource);
          break;
        case 'code':
        case 'firmware':
          await this._viewSoftwareResource(resource);
          break;
        default:
          // 通用文件预览，使用基类方法
          await this.viewFile(file);
      }
    } catch (error) {
      console.error('预览资源失败', error);
      throw error;
    }
  }

  /**
   * 下载资源文件
   * @param {Object} resource - 资源对象
   * @returns {Promise<void>}
   */
  async downloadResource(resource) {
    if (!resource || !resource.RESOURCE_FILE_ID) {
      pageHelper.showError('资源文件不存在');
      return;
    }

    // 标准化资源对象
    const file = {
      fileId: resource.RESOURCE_FILE_ID,
      name: resource.RESOURCE_NAME
    };

    // 使用基类的下载文件方法
    await this.downloadFile(file);
  }

  /**
   * 批量下载资源
   * @param {Array} resources - 资源列表
   * @returns {Promise<void>}
   */
  async batchDownloadResources(resources) {
    // 使用基类的批量下载方法
    await this.batchDownloadFiles(resources, 'RESOURCE_FILE_ID', 'RESOURCE_NAME');
  }

  /**
   * 删除资源
   * @param {string} resourceId - 资源ID
   * @param {string} projectId - 项目ID
   * @returns {Promise<boolean>} 是否删除成功
   */
  async deleteResource(resourceId, projectId) {
    const params = { resourceId };
    
    // 使用基类的删除文件方法
    return await this.deleteFile(resourceId, projectId, 'research/delete_resource', params);
  }

  /**
   * 预览原理图文件
   * @private
   * @param {Object} resource - 资源对象
   * @returns {Promise<void>}
   */
  async _viewSchematicResource(resource) {
    // 特定的原理图预览处理逻辑
    const file = {
      fileId: resource.RESOURCE_FILE_ID,
      name: resource.RESOURCE_NAME
    };
    
    await this.viewFile(file);
  }

  /**
   * 预览PCB文件
   * @private
   * @param {Object} resource - 资源对象
   * @returns {Promise<void>}
   */
  async _viewPcbResource(resource) {
    // 特定的PCB预览处理逻辑
    const file = {
      fileId: resource.RESOURCE_FILE_ID,
      name: resource.RESOURCE_NAME
    };
    
    await this.viewFile(file);
  }

  /**
   * 预览BOM文件
   * @private
   * @param {Object} resource - 资源对象
   * @returns {Promise<void>}
   */
  async _viewBomResource(resource) {
    // 特定的BOM预览处理逻辑
    const file = {
      fileId: resource.RESOURCE_FILE_ID,
      name: resource.RESOURCE_NAME
    };
    
    await this.viewFile(file);
  }

  /**
   * 预览软件相关文件
   * @private
   * @param {Object} resource - 资源对象
   * @returns {Promise<void>}
   */
  async _viewSoftwareResource(resource) {
    // 特定的软件文件预览处理逻辑
    const file = {
      fileId: resource.RESOURCE_FILE_ID,
      name: resource.RESOURCE_NAME
    };
    
    await this.viewFile(file);
  }

  /**
   * 格式化日期时间
   * @private
   * @param {string|Date} datetime - 日期时间
   * @returns {string} 格式化后的日期时间
   */
  _formatDateTime(datetime) {
    if (!datetime) return '';
    
    try {
      // 使用Day.js处理日期
      const date = dayjs(datetime);
      
      // 直接使用Day.js的format方法格式化
      return date.format('YYYY-MM-DD HH:mm:ss');
    } catch (error) {
      console.error('格式化日期时间失败', error);
      return datetime.toString();
    }
  }

  /**
   * 调用API并显示加载中状态
   * @private
   * @param {string} api - API路径
   * @param {Object} params - 请求参数
   * @param {string} loadingText - 加载提示文本
   * @returns {Promise<*>} API响应结果
   */
  async callApiWithLoading(api, params, loadingText) {
    try {
      pageHelper.showLoading(loadingText);
      const result = await cloudHelper.callCloudData(api, params);
      pageHelper.hideLoading();
      return result;
    } catch (error) {
      pageHelper.hideLoading();
      throw error;
    }
  }
}

module.exports = ResourceManager; 